//package com.aliyun.messagemgt.application.service.Impl.push.sanheSms;
//
//import com.alibaba.fastjson.JSONArray;
//import com.alibaba.fastjson.JSONObject;
//import MsgBody;
//import MsgMiddleResult;
//import MsgRecordVO;
//import com.aliyun.messagemgt.application.service.MsgPushChannel;
//import com.aliyun.messagemgt.application.service.SmsMonitorService;
//import com.aliyun.messagemgt.util.SmsQuotaDateUtils;
//import com.aliyun.messagemgt.common.constants.SmsQuotaConstant;
//import com.aliyun.messagemgt.domain.repository.*;
//import com.aliyun.messagemgt.dto.vo.SmsQuotaRequestVO;
//import com.aliyun.messagemgt.dto.vo.SmsQuotaResponseVO;
//import com.aliyun.messagemgt.dto.*;
//import com.aliyun.messagemgt.dto.vo.SmsSignVO;
//import com.aliyun.messagemgt.common.enums.ChannelTypeEnum;
//import com.aliyun.messagemgt.common.errorcode.push.CommonErrorCode;
//import com.aliyun.messagemgt.common.exceptions.BaseException;
//import com.aliyuncs.DefaultAcsClient;
//import com.aliyuncs.IAcsClient;
//import com.aliyuncs.dysmsapi.model.v20170525.SendSmsRequest;
//import com.aliyuncs.dysmsapi.model.v20170525.SendSmsResponse;
//import com.aliyuncs.exceptions.ClientException;
//import com.aliyuncs.http.MethodType;
//import com.aliyuncs.profile.DefaultProfile;
//import com.aliyuncs.profile.IClientProfile;
//import org.apache.commons.collections.CollectionUtils;
//import org.apache.commons.collections.MapUtils;
//import org.apache.commons.lang3.StringUtils;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.stereotype.Service;
//
//import javax.annotation.Resource;
//import java.util.*;
//import java.util.regex.Matcher;
//import java.util.regex.Pattern;
//
///**
// * 短信渠道 对接阿里dysms
// *
// * @author byp
// * @date 2020/4/3
// */
//@Service
//public class DySms implements MsgPushChannel {
//
//    //@Value("${ali.dysms.accessKeyId}")
//    private String accessKeyId;
//    //@Value("${ali.dysms.accessKeySecret}")
//    private String accessKeySecret;
//    //@Value("${ali.dysms.domain}")
//    private String domain;
//    //    @Value("${ali.dysms.signName}")
////    private String signName;
//    //@Value("${ali.dysms.templateCode}")
//    private String templateCode;
//    //@Value("${ali.dysms.regionId}")
//    private String regionId;
//    //@Value("${ali.dysms.product}")
//    private String product;
//
//    private static Logger logger = LoggerFactory.getLogger(DySms.class);
//
//    @Resource
//    private SmsQuotaRepository smsQuotaRepository;
//    @Resource
//    private SmsQuotaUsedRepository smsQuotaUsedRepository;
//    @Resource
//    private SmsQuotaRenewRepository smsQuotaRenewRepository;
//    @Resource
//    private SmsQuotaMonitorRepository smsQuotaMonitorRepository;
//    @Resource
//    private SmsMonitorService smsMonitorService;
//    @Resource
//    private MsgSourceRepository msgSourceRepository;
//    @Resource
//    private IDaaSUserInfoRepository iDaaSUserInfoRepository;
//    @Resource
//    private MessageTemplateRepository messageTemplateRepository;
//    @Resource
//    private SmsSignRepository smsSignRepository;
//
//    private static final Pattern PATTERN = Pattern.compile("\\{(.*?)}");
//
//    @Override
//    public Integer getChannelType() {
//        return ChannelTypeEnum.DYSMS.getType();
//    }
//
//    @Override
//    public void push(PushChannelInfo pushChannelInfo, MsgRecordVO msgRecordVO) throws Exception {
//        //获取接收人的手机号码
//        String phones = getPhones(msgRecordVO);
//        logger.info("短信接收人手机号码：{}", phones);
//        int pushCount = phones.split(",").length;
//        List<MsgMiddleResult> results = msgRecordVO.getResults();
//        //1.发送短信前。进行短信消息源配额校验，判断余量是否够发短信。
//        // 资源预检放这里不是特别合适，资源预检不通过，应直接返回资源方面问题，但是这个只是短信资源的预检。优化的话应该做一个资源预检的接口方法
//        JSONObject checkJson = this.smsQuotaCheck(msgRecordVO, pushCount);
//        Boolean check = checkJson.getBoolean("check");
//        if (!check) {
//            logger.info(checkJson.getString("msg"));
//            this.packageMsgResult(results, DySmsConstant.DYSMS_PUSH_RESULT_ERROR, checkJson.getString("msg"), msgRecordVO.getReceivers());
//            return;
//        }
//        //2020年8月19日修改：新需求，渠道推送使用模板
//        JSONObject templateCheck = templateCheck(msgRecordVO);
//        IClientProfile profile = DefaultProfile.getProfile(regionId, accessKeyId, accessKeySecret);
//        DefaultProfile.addEndpoint(regionId, regionId, product, domain);
//        IAcsClient client = new DefaultAcsClient(profile);
//        // 获取消息签名
//        String sginName = getSmsSgin(String.valueOf(templateCheck.get("msgTemplateId")));
//        //获取发送的信息
//        List<MsgBody> contents = msgRecordVO.getContents();
//        for (MsgBody msgBody : contents) {
//            JSONObject parseAndPackage = parseAndPackageParam(msgBody, templateCheck);
//            Boolean status = parseAndPackage.getBoolean("status");
//            if (!status) {
//                this.packageMsgResult(results, DySmsConstant.DYSMS_PUSH_RESULT_ERROR, parseAndPackage.getString("errorMsg"), msgRecordVO.getReceivers());
//                continue;
//            }
//            //组装请求对象
//            SendSmsRequest request = new SendSmsRequest();
//            request.setMethod(MethodType.POST);
//            if (StringUtils.isEmpty(pushChannelInfo.getSmsTemplateCode())) {
//                request.setTemplateCode(templateCode);
//            } else {
//                request.setTemplateCode(pushChannelInfo.getSmsTemplateCode());
//            }
//
//            request.setSignName(sginName);
//            request.setPhoneNumbers(phones);
//            //可选:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为
//            //友情提示:如果JSON中需要带换行符,请参照标准的JSON协议对换行符的要求,比如短信内容中包含\r\n的情况在JSON中需要表示成\\r\\n,否则会导致JSON在服务端解析失败
//            //参考：request.setTemplateParam("{\"变量1\":\"值1\",\"变量2\":\"值2\",\"变量3\":\"值3\"}")
//            JSONObject params = new JSONObject();
//            String content = parseAndPackage.getString("content");
//            // todo 为进行功能验证先进行更改,等签名下来后更改回去,下边1,2行放开,3行删除
////            params.put("content", content);
////            request.setTemplateParam(params.toString());
//            request.setTemplateParam(msgBody.getContent());
//            //可选-上行短信扩展码(扩展码字段控制在7位或以下，无特殊需求用户请忽略此字段)
//            //request.setSmsUpExtendCode("90997");
//            request.setOutId(UUID.randomUUID().toString());
//            try {
//                SendSmsResponse response = client.getAcsResponse(request);
//                logger.info("发送短信返回信息：{}", response.getMessage());
//                //请求成功
//                if (response.getCode() != null && "OK".equals(response.getCode())) {
//                    this.packageMsgResult(results, DySmsConstant.DYSMS_PUSH_RESULT_SUCCESS, "推送成功", msgRecordVO.getReceivers());
//                    //短信发送成功，used里面数据增加
//                    this.updateUsedSmsQuota(msgRecordVO, pushCount);
//                    //判断是否告警[这里逻辑一定要在续订之前]
//                    this.executeMonitor(msgRecordVO, checkJson, pushCount);
//                    //判断是否续订
//                    this.renewQuotaCheck(msgRecordVO, checkJson, pushCount);
//
//                } else {
//
//                    logger.info("调用阿里短信服务推送失败，失败code：{}，失败信息：{}", response.getCode(), response.getMessage());
//                    this.packageMsgResult(results, DySmsConstant.DYSMS_PUSH_RESULT_ERROR, response.getMessage(), msgRecordVO.getReceivers());
//                }
//
//            } catch (ClientException e) {
//                e.printStackTrace();
//                this.packageMsgResult(results, DySmsConstant.DYSMS_PUSH_RESULT_ERROR, e.getMessage(), msgRecordVO.getReceivers());
//            }
//        }
//    }
//
//    private String getSmsSgin(String smsgTemplateId) {
//        List<SmsSignVO> msgTemplates = smsSignRepository.getSmsSignsPush(smsgTemplateId);
//        if (CollectionUtils.isEmpty(msgTemplates)) {
//            logger.error("消息签名不存在");
//            throw new BaseException(CommonErrorCode.SIGN_EXPIRE);
//        }
//        if (msgTemplates.size() > 1) {
//            logger.error("消息签名获取到多个");
//            throw new BaseException(CommonErrorCode.SIGN_EXPIRE);
//        }
//        return msgTemplates.get(0).getSignName();
//
//    }
//
//    /**
//     * 封装消息返回结果
//     *
//     * @param results               结果集合
//     * @param pushResultCode        推送状态码
//     * @param pushResultDescription 推送结果描述
//     * @param receivers             接收人
//     */
//    private void packageMsgResult(List<MsgMiddleResult> results, Integer pushResultCode, String pushResultDescription, List<Receiver> receivers) {
//        MsgMiddleResult msgMiddleResult = new MsgMiddleResult().setPushResultCode(pushResultCode)
//                .setPushResultDescription(pushResultDescription)
//                .setReceivers(receivers);
//        results.add(msgMiddleResult);
//    }
//
//    /**
//     * 获取短信接收人手机号列表
//     *
//     * @param msgRecordVO vo
//     * @return String
//     */
//    private String getPhones(MsgRecordVO msgRecordVO) {
//        String phones = "";
//        List<FourAObjectEntity> pushUserIds = msgRecordVO.getPushUserIds();
//        List<String> phoneList = new ArrayList<>();
//        for (FourAObjectEntity pushUserId : pushUserIds) {
//            if (StringUtils.isNotBlank(pushUserId.getKey())) {
//                phoneList.add(pushUserId.getKey());
//            }
//        }
//        if (phoneList.size() > 0) {
//            phones = String.join(",", phoneList);
//        }
//        return phones;
//    }
//
//    /**
//     * 校验余量是否允许发送短信
//     * 1-1校验时，查询是否有续订信息
//     * 1-2添加续订信息之前，先进行判断当前生效的短信配额是否有续订额信息。 1.有再查询续订额 2.没有（此情况为了防止立即生效，取消了短信续订）
//     * 1-3【2020年7月22日与PD沟通】特殊情况：如果推送量>总余额，并且有配置了续订信息。那么需要添加续订额保证：1.通过此次资源预检。2.不再触发续订
//     * 1-3暂未实现
//     *
//     * @param msgRecordVO 消息体
//     * @param pushCount   推送量
//     * @return json
//     */
//    private JSONObject smsQuotaCheck(MsgRecordVO msgRecordVO, Integer pushCount) {
//        logger.info("短信额度预检");
//        JSONObject check = new JSONObject();
//        //查询该消息源的短信配额
//        SmsQuotaRequestVO query = new SmsQuotaRequestVO();
//        query.setMsgSourceId(msgRecordVO.getMsgSourceId());
//        query.setEffectiveStatus(SmsQuotaConstant.EFFECTIVE_STATUS_SHENGXIAO);
//        List<SmsQuotaResponseVO> list = smsQuotaRepository.querySmsQuotaList(query);
//        if (CollectionUtils.isEmpty(list)) {
//            check.put("msg", "未查询到该消息源的短信配额");
//            check.put("check", false);
//            return check;
//        }
//        SmsQuotaResponseVO smsQuotaResponseVO = list.get(0);
//        SmsQuota smsQuota = smsQuotaResponseVO.getSmsQuota();
//        //已使用列表
//        SmsQuotaUsed usedQuery = new SmsQuotaUsed();
//        usedQuery.setMsgSourceId(msgRecordVO.getMsgSourceId());
//        List<SmsQuotaUsed> usedList = smsQuotaUsedRepository.querySmsQuotaUsedByEntity(usedQuery);
//        //续订量
//        int renewQuota = 0;
//        if (smsQuota.getRenewQuota() != null) {
//            //续订列表
//            SmsQuotaRenew renewQuery = new SmsQuotaRenew().setMsgSourceId(msgRecordVO.getMsgSourceId()).setStatus(1);
//            List<SmsQuotaRenew> renewList = smsQuotaRenewRepository.queryRenewListByEntity(renewQuery);
//            if (CollectionUtils.isNotEmpty(renewList)) {
//                if (SmsQuotaConstant.QUOTA_TYPE_YEAR.equals(smsQuota.getQuotaType())) {
//                    //年度
//                    renewQuota = renewList.stream().filter(smsQuotaRenew -> smsQuotaRenew.getRenewYear().equals(SmsQuotaDateUtils.currentYear()))
//                            .mapToInt(SmsQuotaRenew::getRenewQuota).sum();
//                } else {
//                    //月度
//                    renewQuota = renewList.stream().filter(smsQuotaRenew -> smsQuotaRenew.getRenewYear().equals(SmsQuotaDateUtils.currentYear()) &&
//                            smsQuotaRenew.getRenewMonth().equals(SmsQuotaDateUtils.currentMonth()))
//                            .mapToInt(SmsQuotaRenew::getRenewQuota).sum();
//                }
//            }
//        }
//        //总额=固定配额*包数量+续订总额
//        int quotaCount;
//        if (smsQuota.getQuotaPackageNum() == null) {
//            quotaCount = smsQuota.getQuota() + renewQuota;
//        } else {
//            quotaCount = smsQuota.getQuota() * smsQuota.getQuotaPackageNum() + renewQuota;
//        }
//        //使用量
//        int usedQuota = 0;
//        if (CollectionUtils.isEmpty(usedList)) {
//            logger.info("使用配额信息为空");
//            //使用配额信息为空，直接判断发送数量是否超过短信配额
//            if (pushCount > quotaCount) {
//                //查询是否有配置续订信息。
//                logger.info("可使用短信配额{} 不足以支持本次发送量{}", smsQuota.getQuota(), pushCount);
//                check.put("msg", "该消息源的可使用短信配额不足以支持本次发送量");
//                check.put("check", false);
//                return check;
//            }
//            check.put("check", true);
//            check.put("quotaCount", quotaCount);
//            check.put("usedQuota", usedQuota);
//            return check;
//        }
//        if (SmsQuotaConstant.QUOTA_TYPE_YEAR.equals(smsQuota.getQuotaType())) {
//            usedQuota = usedList.stream().filter(smsQuotaUsed ->
//                    StringUtils.equals(smsQuotaUsed.getUsedYear(), SmsQuotaDateUtils.currentYear()))
//                    .mapToInt(SmsQuotaUsed::getUsedQuota).sum();
//        } else {
//            SmsQuotaUsed used = usedList.stream().filter(smsQuotaUsed ->
//                    StringUtils.equals(smsQuotaUsed.getUsedYear(), SmsQuotaDateUtils.currentYear())
//                            && StringUtils.equals(smsQuotaUsed.getUsedMonth(), SmsQuotaDateUtils.currentMonth()))
//                    .findAny().orElse(null);
//            if (used != null) {
//                usedQuota = used.getUsedQuota();
//            }
//        }
//        //余量
//        int residue = quotaCount - usedQuota;
//        if (residue < pushCount) {
//            logger.info("可使用短信配额余量{} 不足以支持本次发送量{}", residue, pushCount);
//            check.put("msg", "该消息源的可使用短信配额余量不足以支持本次发送量");
//            check.put("check", false);
//            return check;
//        }
//        check.put("check", true);
//        check.put("quotaCount", quotaCount);
//        check.put("usedQuota", usedQuota);
//        return check;
//    }
//
//    /**
//     * 发送成功之后 更新已使用短信配额
//     *
//     * @param msgRecordVO 消息体
//     * @param pushCount   推送量
//     */
//    private void updateUsedSmsQuota(MsgRecordVO msgRecordVO, Integer pushCount) {
//        logger.info("更新已使用短信配额 begin");
//        String msgSourceId = msgRecordVO.getMsgSourceId();
//        SmsQuotaUsed query = new SmsQuotaUsed();
//        query.setMsgSourceId(msgSourceId);
//        query.setUsedMonth(SmsQuotaDateUtils.currentMonth());
//        query.setUsedYear(SmsQuotaDateUtils.currentYear());
//        List<SmsQuotaUsed> usedList = smsQuotaUsedRepository.querySmsQuotaUsedByEntity(query);
//        if (CollectionUtils.isEmpty(usedList)) {
//            //空 新增记录
//            query.setUsedQuota(pushCount);
//            query.setUpdateTime(new Date());
//            smsQuotaUsedRepository.insert(query);
//            logger.info("新增已使用短信配额记录");
//        } else {
//            //非空 更新
//            SmsQuotaUsed used = usedList.get(0);
//            int usedQuota = used.getUsedQuota() + pushCount;
//            used.setUsedQuota(usedQuota);
//            smsQuotaUsedRepository.update(used);
//            logger.info("更新已使用短信配额记录");
//        }
//        logger.info("更新已使用短信配额 end");
//    }
//
//    /**
//     * 续订检查
//     *
//     * @param msgRecordVO 消息体
//     * @param checkJson   资源预检返回数据
//     * @param pushCount   推送量
//     */
//    private void renewQuotaCheck(MsgRecordVO msgRecordVO, JSONObject checkJson, Integer pushCount) {
//        logger.info("续订 begin");
//        SmsQuota smsQuota = smsQuotaRepository.queryQuotaByMsgSourceIdAndStatus(msgRecordVO.getMsgSourceId(), SmsQuotaConstant.EFFECTIVE_STATUS_SHENGXIAO);
//        if (smsQuota.getRenewQuota() == null) {
//            logger.info("该消息源短信配额无续订信息");
//            return;
//        }
//        int renewMarginQuota = smsQuota.getRenewMarginQuota() == null ? 0 : smsQuota.getRenewMarginQuota();
//
//        int quotaCount = checkJson.getIntValue("quotaCount");
//        int usedQuota = checkJson.getIntValue("usedQuota");
//        int residue = quotaCount - usedQuota - pushCount;
//        logger.info("该消息源续订触发额度：{},短信配额总量：{}，使用量：{}，推送量：{}，余量：{}", renewMarginQuota, quotaCount, usedQuota, pushCount, residue);
//        if (residue >= renewMarginQuota) {
//            logger.info("未触发续订");
//            return;
//        }
//        int renewQuota = smsQuota.getRenewQuota();
//        //差值
//        int diff = renewMarginQuota - residue;
//        //续订数量
//        int renewNum = (int) Math.ceil((double) diff / renewQuota);
//        List<SmsQuotaRenew> renewList = new ArrayList<>();
//        SmsQuotaRenew renew;
//        for (int i = 0; i < renewNum; i++) {
//            renew = new SmsQuotaRenew().setMsgSourceId(msgRecordVO.getMsgSourceId())
//                    .setRenewMonth(SmsQuotaDateUtils.currentMonth())
//                    .setRenewYear(SmsQuotaDateUtils.currentYear())
//                    .setRenewQuota(smsQuota.getRenewQuota())
//                    .setRenewType(smsQuota.getQuotaType())
//                    .setCreateTime(new Date())
//                    .setUpdateTime(new Date())
//                    .setStatus(1);
//            renewList.add(renew);
//        }
//        smsQuotaRenewRepository.insertList(renewList);
//        //续订总量
//        int renewQuotaCount = renewQuota * renewNum;
//        logger.info("判断续订额度是否达到告警值 begin");
//        Integer monitorQuota = smsQuota.getMonitorMarginQuota();
//        if (monitorQuota != null) {
//            if (residue + renewQuotaCount > monitorQuota) {
//                logger.info("续订后高于告警值");
//                SmsQuotaMonitor monitor = smsQuotaMonitorRepository.selectMonitorByMsgSourceIdAndStatus(smsQuota.getMsgSourceId(), SmsQuotaConstant.MONITOR_STATUS_SHIXIAO);
//                if (monitor != null) {
//                    logger.info("重新设置告警状态为启用");
//                    monitor.setStatus(SmsQuotaConstant.MONITOR_STATUS_SHENGXIAO);
//                    smsQuotaMonitorRepository.update(monitor);
//                }
//            }
//        }
//        logger.info("判断续订额度是否达到告警值 end");
//        logger.info("续订 end");
//    }
//
//
//    //2020年7月23日14:57:14与PD任亮沟通告警规则如果下
//    //1.在使用短信消息源发送短信时，触发告警
//    //2.触发告警分为两种情况：a.没有续订 b.有续订
//    //2.1没有续订情况：多次触发，只告警一次。
//    //2.2有续订情况：a.续订之后没有达到告警值。续订之前如果告警过一次，这里续订后没有超过告警值，那么不再告警
//    //             b.续订之后超过告警值。余量在 (续订触发值,告警值] 这个区间，只告警一次。
//    //             再次续订，满足条件，再次告警（只告警一次）
//    //2.3 以上两种情况都有共同的两种情况：
//    //      a.修改配额包大小。调大：再次达到告警值，只告警一次
//    //      b.修改告警值大小。调小：再次达到告警值，只告警一次
//
//    /**
//     * 告警
//     * 告警逻辑的情况已经分布在续订，与修改配置逻辑中
//     *
//     * @param checkJson 预检里的使用量
//     */
//    private void executeMonitor(MsgRecordVO msgRecordVO, JSONObject checkJson, Integer pushCount) throws ClientException {
//        logger.info("短信配额告警 begin");
//        int quotaCount = checkJson.getIntValue("quotaCount");
//        int usedQuota = checkJson.getIntValue("usedQuota");
//        int residue = quotaCount - usedQuota - pushCount;
//        //查询启用的监控
//        SmsQuotaMonitor monitor = smsQuotaMonitorRepository.selectMonitorByMsgSourceIdAndStatus(msgRecordVO.getMsgSourceId(), 1);
//        if (monitor == null) {
//            logger.info("未查到启用的监控信息");
//            return;
//        }
//        int monitorQuota = monitor.getMonitorQuota();
//        logger.info("消息源：{} 短信配额总量：{} 使用量：{} 余量：{} 触发告警量：{}", msgRecordVO.getMsgSourceId(), quotaCount, usedQuota, residue, monitorQuota);
//        if (residue >= monitorQuota) {
//            logger.info("未触发告警");
//            return;
//        }
//        //这里通过消息源UUID查询消息源数据。不用查询短信配额中的管理员。消息源可能会改变管理员信息
//        MsgSource msgSource = msgSourceRepository.getMsgSourceBySourceCode(msgRecordVO.getMsgSourceId());
//        if (msgSource == null) {
//            logger.info("消息源：{}异常", msgRecordVO.getMsgSourceId());
//            return;
//        }
//        String owner = msgSource.getOwner();
//        if (StringUtils.isBlank(owner)) {
//            logger.info("未查到消息源额管理员信息");
//            return;
//        }
//        JSONArray ownerJson = JSONArray.parseArray(owner);
//        List<String> phoneList = new ArrayList<>();
//        for (int i = 0; i < ownerJson.size(); i++) {
//            JSONObject jsonObject = ownerJson.getJSONObject(i);
//            String key = jsonObject.getString("key");
//            UserInfo userInfo = iDaaSUserInfoRepository.queryUserByUserCode(key);
//            if (userInfo != null && StringUtils.isNotBlank(userInfo.getUserMobile())) {
//                phoneList.add(userInfo.getUserMobile());
//            }
//        }
//        if (phoneList.size() > 0) {
//            String phones = String.join(",", phoneList);
//            smsMonitorService.executeMonitor(phones, monitor.getMonitorQuota().toString());
//            //执行结束后更新状态为2
//            monitor.setStatus(SmsQuotaConstant.MONITOR_STATUS_SHIXIAO);
//            smsQuotaMonitorRepository.update(monitor);
//        } else {
//            logger.info("未查到该消息源管理员的有效手机号码");
//        }
//        logger.info("短信配额告警 end");
//    }
//
//
//    /**
//     * 使用消息模板推送检查
//     * 1.消息源是否使用模板
//     * 2.消息体是否按照模板要求入参
//     *
//     * @param msgRecordVO 消息记录
//     * @return json
//     */
//    private JSONObject templateCheck(MsgRecordVO msgRecordVO) {
//        JSONObject result = new JSONObject();
//        logger.info("进行消息模板推送检查");
//        String msgSourceId = msgRecordVO.getMsgSourceId();
//        logger.info("查询该消息源是否绑定消息模板");
////        MessageTemplate query = new MessageTemplate().setMsgSourceId(msgSourceId);
////        MessageTemplate bindTemplate = messageTemplateRepository.queryByEntity(query);
//        /*if (bindTemplate == null) {
//            logger.info("未绑定消息模板");
//            result.put("activeTemplate", false);
//            throw new BaseException(CommonErrorCode.SIGN_EXPIRE);
//        }
//        logger.info("该消息源绑定消息模板");
//        String displayContent = bindTemplate.getDescription();
//        String fields = bindTemplate.getTemplateContent();
//        //获取字段中的所有变量名
//        JSONObject parse = jsonParseKeyAndValue(JSONObject.parseObject(fields));
//        JSONArray variate = parse.getJSONArray("valueList");
//        result.put("activeTemplate", true);
//        result.put("variateList", variate);
//        result.put("displayContent", displayContent);
//        result.put("msgTemplateId", bindTemplate.getTemplateId());*/
//        return result;
//    }
//
//    /**
//     * 将json格式的变量解析key和value集合
//     *
//     * @param jsonObject json变量
//     * @return json
//     */
//    private JSONObject jsonParseKeyAndValue(JSONObject jsonObject) {
//        List<String> keyList = new ArrayList<>();
//        List<String> valueList = new ArrayList<>();
//        for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
//            keyList.add(entry.getKey());
//            valueList.add((String) entry.getValue());
//        }
//        JSONObject result = new JSONObject();
//        result.put("keyList", keyList);
//        result.put("valueList", valueList);
//        return result;
//    }
//
//
//    /**
//     * 解析并拼接消息体
//     *
//     * @param msgBody       消息体
//     * @param templateCheck 模板检查返回结果
//     * @return json 包含1.解析并拼接状态 2.拼接后消息体 3.异常的话异常信息
//     */
//    private JSONObject parseAndPackageParam(MsgBody msgBody, JSONObject templateCheck) {
//        JSONObject parseAndPackage = new JSONObject();
//        String content = msgBody.getContent();
//        Boolean templateActive = templateCheck.getBoolean("activeTemplate");
//        if (templateActive) {
//            logger.info("消息源绑定模板");
//            try {
//                JSONArray templateValue = templateCheck.getJSONArray("variateList");
//                JSONObject contentJson = jsonParseKeyAndValue(JSONObject.parseObject(content));
//                JSONArray contentKey = contentJson.getJSONArray("keyList");
//                if (templateValue.size() != contentKey.size()) {
//                    logger.info("发送内容与模板定义的参数不匹配");
//                    parseAndPackage.put("status", false);
//                    parseAndPackage.put("errorMsg", "发送内容与模板定义的参数不匹配");
//                }
//                logger.info("拼接模板消息");
//                String template = templateCheck.getString("displayContent");
//                String parseTemplate = this.templateParseWithMap(template, JSONObject.parseObject(content));
//                logger.info("拼接的模板消息为：{}", parseTemplate);
//                if (StringUtils.isBlank(parseTemplate)) {
//                    parseAndPackage.put("status", false);
//                    parseAndPackage.put("errorMsg", "模板为空或者发送内容为空");
//                }
//                parseAndPackage.put("status", true);
//                parseAndPackage.put("content", parseTemplate);
//
//            } catch (Exception e) {
//                logger.info("解析发送内容报错，请核对发送内容");
//                parseAndPackage.put("status", false);
//                parseAndPackage.put("errorMsg", "解析发送内容报错，请核对发送内容");
//            }
//        } else {
//            logger.info("消息源未绑定模板");
//            parseAndPackage.put("status", true);
//            parseAndPackage.put("content", content);
//        }
//        return parseAndPackage;
//    }
//
//
//    /**
//     * 模板参数解析返回消息体
//     *
//     * @param template 模板
//     * @param param    参数
//     * @return 解析后消息体
//     */
//    private String templateParseWithMap(String template, Map<String, Object> param) {
//        if (StringUtils.isBlank(template) || MapUtils.isEmpty(param)) {
//            return null;
//        }
//        Matcher matcher = PATTERN.matcher(template);
//        while (matcher.find()) {
//            try {
//                String key = matcher.group();
//                //如果占位符是${} 这里就是key.substring(2, key.length() - 1).trim()
//                String keyClone = key.substring(1, key.length() - 1).trim();
//                Object value = param.get(keyClone);
//                if (value != null) {
//                    template = template.replace(key, value.toString());
//                }
//            } catch (Exception e) {
//                throw new RuntimeException("String formatter failed", e);
//            }
//        }
//        return template;
//    }
//}
